const UserModel = require('../models/userModel');
const EmailService = require('../utils/emailService');
const jwt = require('jsonwebtoken');
const { secret, expiresIn } = require('../config/jwtConfig');
const formatDate = require('../utils/dateFormat');
const visitorManager = require('../utils/visitorManager');
const { v4: uuidv4 } = require('uuid'); // 需要安装：npm install uuid

class UserController {
    // 创建用户
    static async create(req, res) {
        try {
            const result = await UserModel.create(req.body);
            res.status(201).json({
                status: 'success',
                data: result
            });
        } catch (error) {
            res.status(400).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 获取所有用户
    static async getAll(req, res) {
        try {
            const users = await UserModel.findAll();
            res.status(200).json({
                status: 'success',
                data: users
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 获取单个用户
    static async getOne(req, res) {
        try {
            const user = await UserModel.findById(req.params.id);
            if (!user) {
                return res.status(404).json({
                    status: 'error',
                    message: '用户不存在'
                });
            }
            res.status(200).json({
                status: 'success',
                data: user
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 更新用户
    static async update(req, res) {
        try {
            const result = await UserModel.update(req.params.id, req.body);
            res.status(200).json({
                status: 'success',
                data: result
            });
        } catch (error) {
            res.status(400).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 删除用户
    static async delete(req, res) {
        try {
            await UserModel.delete(req.params.id);
            res.status(200).json({
                status: 'success',
                message: '用户已删除'
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 根据邮箱获取用户
    static async getByEmail(req, res) {
        try {
            const user = await UserModel.findByEmail(req.params.email);
            if (!user) {
                return res.status(404).json({
                    status: 'error',
                    message: '用户不存在'
                });
            }
            res.status(200).json({
                status: 'success',
                data: user
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 发送验证码
    static async sendVerificationCode(req, res) {
        try {
            const { email } = req.body;

            // 检查邮箱格式
            if (!email || !/^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/.test(email)) {
                return res.status(400).json({
                    status: 'error',
                    message: '邮箱格式不正确'
                });
            }

            // 检查邮箱是否已被注册
            const exists = await UserModel.checkEmailExists(email);
            if (exists) {
                return res.status(400).json({
                    status: 'error',
                    message: '该邮箱已被注册'
                });
            }

            // 发送验证码
            await EmailService.sendVerificationCode(email);

            res.status(200).json({
                status: 'success',
                message: '验证码已发送，请查收'
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 用户注册
    static async register(req, res) {
        try {
            const { email, name, password, verificationCode, avatar } = req.body;

            // 验证必填字段
            if (!email || !name || !password || !verificationCode) {
                return res.status(400).json({
                    status: 'error',
                    message: '邮箱、用户名、密码和验证码是必填的'
                });
            }

            // 验证验证码
            if (!EmailService.verifyCode(email, verificationCode)) {
                return res.status(400).json({
                    status: 'error',
                    message: '验证码无效或已过期'
                });
            }

            // 检查邮箱是否已被注册
            const exists = await UserModel.checkEmailExists(email);
            if (exists) {
                return res.status(400).json({
                    status: 'error',
                    message: '该邮箱已被注册'
                });
            }

            // 创建用户
            const userData = {
                email,
                name,
                password, // 注意：实际应用中应该对密码进行加密
                avatar   // 如果avatar为undefined，数据库会使用默认值
            };

            const result = await UserModel.register(userData);

            res.status(201).json({
                status: 'success',
                message: '注册成功',
                data: {
                    id: result.insertId
                }
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 生成 JWT token
    static generateToken(user) {
        return jwt.sign(
            { id: user.id, email: user.email },
            secret,
            { expiresIn }
        );
    }

    // 格式化用户信息
    static formatUserInfo(user) {
        if (!user) return null;
        const { password: _, ...userInfo } = user;
        return {
            ...userInfo,
            birthdate: formatDate(userInfo.birthdate)
        };
    }

    // 密码登录
    static async loginWithPassword(req, res) {
        try {
            const { email, password } = req.body;

            // 验证必填字段
            if (!email || !password) {
                return res.status(400).json({
                    status: 'error',
                    message: '邮箱和密码是必填的'
                });
            }

            // 查找用户
            const user = await UserModel.findByEmailWithPassword(email);

            // 用户不存在
            if (!user) {
                return res.status(401).json({
                    status: 'error',
                    message: '邮箱或密码错误'
                });
            }

            // 验证密码（注意：实际应用中应该使用加密比对）
            if (user.password !== password) {
                return res.status(401).json({
                    status: 'error',
                    message: '邮箱或密码错误'
                });
            }

            // 生成 token
            const token = UserController.generateToken(user);

            // 返回用户信息和token
            res.status(200).json({
                status: 'success',
                message: '登录成功',
                data: {
                    token,
                    user: UserController.formatUserInfo(user)
                }
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 验证码登录
    static async loginWithCode(req, res) {
        try {
            const { email, verificationCode } = req.body;

            // 验证必填字段
            if (!email || !verificationCode) {
                return res.status(400).json({
                    status: 'error',
                    message: '邮箱和验证码是必填的'
                });
            }

            // 验证验证码
            if (!EmailService.verifyCode(email, verificationCode)) {
                return res.status(401).json({
                    status: 'error',
                    message: '验证码无效或已过期'
                });
            }

            // 查找用户
            const user = await UserModel.findByEmailWithPassword(email);

            // 用户不存在
            if (!user) {
                return res.status(401).json({
                    status: 'error',
                    message: '用户不存在'
                });
            }

            // 生成 token
            const token = UserController.generateToken(user);

            // 返回用户信息和token
            res.status(200).json({
                status: 'success',
                message: '登录成功',
                data: {
                    token,
                    user: UserController.formatUserInfo(user)
                }
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 发送登录验证码
    static async sendLoginCode(req, res) {
        try {
            const { email } = req.body;

            // 检查邮箱格式
            if (!email || !/^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/.test(email)) {
                return res.status(400).json({
                    status: 'error',
                    message: '邮箱格式不正确'
                });
            }

            // 检查用户是否存在
            const exists = await UserModel.checkEmailExists(email);
            if (!exists) {
                return res.status(400).json({
                    status: 'error',
                    message: '用户不存在'
                });
            }

            // 发送验证码
            await EmailService.sendVerificationCode(email);

            res.status(200).json({
                status: 'success',
                message: '验证码已发送，请查收'
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 重置密码
    static async resetPassword(req, res) {
        try {
            const { email, newPassword, verificationCode } = req.body;

            // 验证必填字段
            if (!email || !newPassword || !verificationCode) {
                return res.status(400).json({
                    status: 'error',
                    message: '邮箱、新密码和验证码是必填的'
                });
            }

            // 验证验证码
            if (!EmailService.verifyCode(email, verificationCode)) {
                return res.status(401).json({
                    status: 'error',
                    message: '验证码无效或已过期'
                });
            }

            // 检查用户是否存在
            const exists = await UserModel.checkEmailExists(email);
            if (!exists) {
                return res.status(404).json({
                    status: 'error',
                    message: '用户不存在'
                });
            }

            // 重置密码
            await UserModel.resetPassword(email, newPassword);

            res.status(200).json({
                status: 'success',
                message: '密码重置成功'
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 发送重置密码验证码
    static async sendResetPasswordCode(req, res) {
        try {
            const { email } = req.body;

            // 检查邮箱格式
            if (!email || !/^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/.test(email)) {
                return res.status(400).json({
                    status: 'error',
                    message: '邮箱格式不正确'
                });
            }

            // 检查用户是否存在
            const exists = await UserModel.checkEmailExists(email);
            if (!exists) {
                return res.status(404).json({
                    status: 'error',
                    message: '用户不存在'
                });
            }

            // 发送验证码
            await EmailService.sendVerificationCode(email);

            res.status(200).json({
                status: 'success',
                message: '验证码已发送，请查收'
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 获取当前用户信息
    static async getCurrentUser(req, res) {
        try {
            const user = await UserModel.findById(req.user.id);

            if (!user) {
                return res.status(404).json({
                    status: 'error',
                    message: '用户不存在'
                });
            }

            const newToken = UserController.generateToken(user);

            res.status(200).json({
                status: 'success',
                data: {
                    token: newToken,
                    user: UserController.formatUserInfo(user)
                }
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 更新用户信息
    static async updateUserInfo(req, res) {
        try {
            const { name, gender, birthdate, avatar } = req.body;
            const userId = req.user.id; // 从 token 中获取用户 ID

            // 验证必填字段
            if (!name) {
                return res.status(400).json({
                    status: 'error',
                    message: '用户名是必填项'
                });
            }

            // 验证性别值
            if (gender && !['male', 'female'].includes(gender)) {
                return res.status(400).json({
                    status: 'error',
                    message: '性别值无效'
                });
            }

            // 验证日期格式
            if (birthdate && !(/^\d{4}-\d{2}-\d{2}$/.test(birthdate))) {
                return res.status(400).json({
                    status: 'error',
                    message: '出生日期格式无效，应为 YYYY-MM-DD'
                });
            }

            // 构建更新数据
            const updateData = {
                name,
                gender,
                birthdate,
                avatar
            };

            // 移除未提供的字段
            Object.keys(updateData).forEach(key => {
                if (updateData[key] === undefined) {
                    delete updateData[key];
                }
            });

            // 更新用户信息
            await UserModel.updateUserInfo(userId, updateData);

            // 获取更新后的用户信息
            const updatedUser = await UserModel.findById(userId);
            const newToken = UserController.generateToken(updatedUser);

            res.status(200).json({
                status: 'success',
                message: '用户信息更新成功',
                data: {
                    token: newToken,
                    user: UserController.formatUserInfo(updatedUser)
                }
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 获取用户关系列表
    static async getUserRelationships(req, res) {
        try {
            const userId = req.params.userId || req.user.id;
            const relationships = await UserModel.getUserRelationships(userId);

            res.status(200).json({
                status: 'success',
                data: relationships
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 获取向指定用户发送的好友申请列表
    static async getFriendRequests(req, res) {
        try {
            const userId = req.params.userId || req.user.id;
            const friendRequests = await UserModel.getFriendRequests(userId);

            res.status(200).json({
                status: 'success',
                data: friendRequests
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 更新用户关系
    static async updateRelationship(req, res) {
        try {
            const { userId, friendId, relationship } = req.body;

            // 验证必要参数
            if (!userId || !friendId || relationship === undefined) {
                return res.status(400).json({
                    status: 'error',
                    message: '用户ID、好友ID和关系数据是必需的'
                });
            }

            // 确保relationship是字符串
            if (typeof relationship !== 'string') {
                return res.status(400).json({
                    status: 'error',
                    message: '关系数据必须是字符串类型'
                });
            }

            // 验证用户是否有权限更新此关系
            if (req.user.id != userId && req.user.id != friendId) {
                return res.status(403).json({
                    status: 'error',
                    message: '您没有权限更新此关系'
                });
            }

            const result = await UserModel.updateRelationship(userId, friendId, relationship);

            if (result.affectedRows === 0) {
                return res.status(404).json({
                    status: 'error',
                    message: '关系不存在'
                });
            }

            res.status(200).json({
                status: 'success',
                message: '关系已更新',
                data: result
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 创建用户关系
    static async createRelationship(req, res) {
        try {
            const { userId, friendId, relationship } = req.body;

            // 验证必要参数
            if (!userId || !friendId || relationship === undefined) {
                return res.status(400).json({
                    status: 'error',
                    message: '用户ID、好友ID和关系数据是必需的'
                });
            }

            // 确保relationship是字符串
            if (typeof relationship !== 'string') {
                return res.status(400).json({
                    status: 'error',
                    message: '关系数据必须是字符串类型'
                });
            }

            // 验证用户是否有权限创建此关系
            if (req.user.id != userId) {
                return res.status(403).json({
                    status: 'error',
                    message: '您没有权限创建此关系'
                });
            }

            const result = await UserModel.createRelationship(userId, friendId, relationship);

            // 检查是否真正创建成功
            if (result && result.affectedRows > 0) {
                res.status(201).json({
                    status: 'success',
                    message: '关系已创建',
                    data: result
                });
            } else {
                res.status(500).json({
                    status: 'error',
                    message: '创建关系失败'
                });
            }
        } catch (error) {
            if (error.message === '关系已存在') {
                return res.status(409).json({
                    status: 'error',
                    message: error.message
                });
            }
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 游客登录
    static async visitorLogin(req, res) {
        try {
            const { name, avatar } = req.body;

            // 验证必填字段
            if (!name || !avatar) {
                return res.status(400).json({
                    status: 'error',
                    message: '昵称和头像是必填的'
                });
            }

            // 检查昵称长度
            if (name.length < 2 || name.length > 20) {
                return res.status(400).json({
                    status: 'error',
                    message: '昵称长度必须在2-20个字符之间'
                });
            }

            // 使用事务或锁机制来确保检查和添加的原子性
            const checkAndAddVisitor = async () => {
                // 1. 检查昵称是否已被注册用户使用
                const existingUser = await UserModel.findByName(name);
                if (existingUser) {
                    throw new Error('该昵称已被注册用户使用');
                }

                // 2. 检查昵称是否已被其他在线游客使用
                if (visitorManager.hasVisitor(name)) {
                    throw new Error('该昵称已被其他游客使用');
                }

                // 3. 创建游客信息
                const visitorInfo = {
                    id: `visitor_${uuidv4()}`,
                    name,
                    avatar,
                    isVisitor: true,
                    createdAt: new Date()
                };

                // 4. 预先添加到游客管理器
                visitorManager.addVisitorWithoutSocket(name, visitorInfo);

                return visitorInfo;
            };

            // 执行检查和添加操作
            const visitorInfo = await checkAndAddVisitor();

            // 生成游客token
            const token = jwt.sign(
                {
                    id: visitorInfo.id,
                    name: visitorInfo.name,
                    avatar: visitorInfo.avatar,
                    isVisitor: true
                },
                secret,
                { expiresIn }
            );

            res.status(200).json({
                status: 'success',
                message: '游客登录成功',
                data: {
                    token,
                    user: visitorInfo
                }
            });

        } catch (error) {
            res.status(400).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 获取用户列表（分页）
    static async getUsersList(req, res) {
        try {
            const { limit = 10, offset = 0 } = req.query;
            const users = await UserModel.getUsersWithPagination(limit, offset);
            res.status(200).json({
                status: 'success',
                data: users
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }

    // 搜索用户
    static async searchUsers(req, res) {
        try {
            const { keywords, limit = 10, offset = 0 } = req.query;

            // 验证关键词
            if (!keywords || keywords.trim() === '') {
                return res.status(400).json({
                    status: 'error',
                    message: '搜索关键词是必需的'
                });
            }

            const users = await UserModel.searchUsers(keywords, limit, offset);
            res.status(200).json({
                status: 'success',
                data: users
            });
        } catch (error) {
            res.status(500).json({
                status: 'error',
                message: error.message
            });
        }
    }
}

module.exports = UserController; 